JavaScript Async Iterator Yordamchilarida Xatoliklarni Uzatish: Mustahkam Ilovalar Uchun Oqimlardagi Xatoliklarni Boshqarish

Asinxron dasturlash zamonaviy JavaScript dasturlashida, ayniqsa ma'lumotlar oqimlari bilan ishlashda keng tarqalgan. Asinxron iteratorlar va asinxron generator funksiyalari ma'lumotlarni asinxron tarzda, elementma-element qayta ishlash uchun kuchli vositalarni taqdim etadi. Biroq, ushbu tuzilmalar ichida xatoliklarni to'g'ri boshqarish mustahkam va ishonchli ilovalar yaratish uchun juda muhimdir. Ushbu keng qamrovli qo'llanma JavaScript-ning asinxron iterator yordamchilarida xatoliklarni uzatishning nozikliklarini o'rganadi, oqimli ilovalarda xatoliklarni samarali boshqarish uchun amaliy misollar va eng yaxshi amaliyotlarni taqdim etadi.

Asinxron Iteratorlar va Asinxron Generator Funksiyalarini Tushunish

Xatoliklarni boshqarishga kirishishdan oldin, keling, asinxron iteratorlar va asinxron generator funksiyalarining asosiy tushunchalarini qisqacha ko'rib chiqaylik.

Asinxron Iteratorlar

Asinxron iterator - bu next() metodini taqdim etuvchi ob'ekt bo'lib, u value va done xususiyatlariga ega ob'ektga hal qilinadigan promisni qaytaradi. value xususiyati ketma-ketlikdagi keyingi qiymatni saqlaydi va done xususiyati iteratorning tugaganligini bildiradi.

Misol:

            async function* createAsyncIterator(data) {
  for (const item of data) {
    await new Promise(resolve => setTimeout(resolve, 50)); // Asinxron operatsiyani simulyatsiya qilish
    yield item;
  }
}

const asyncIterator = createAsyncIterator([1, 2, 3]);

async function consumeIterator() {
  let result = await asyncIterator.next();
  while (!result.done) {
    console.log(result.value);
    result = await asyncIterator.next();
  }
}

consumeIterator(); // Natija: 1, 2, 3 (kechikishlar bilan)
            

              
                Copy
              
            
          

Asinxron Generator Funksiyalari

Asinxron generator funksiyasi - bu asinxron iteratorni qaytaradigan maxsus turdagi funksiya. U qiymatlarni asinxron tarzda ishlab chiqarish uchun yield kalit so'zidan foydalanadi.

Misol:

            async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Asinxron operatsiyani simulyatsiya qilish
    yield i;
  }
}

async function consumeGenerator() {
  for await (const num of generateSequence(1, 5)) {
    console.log(num);
  }
}

consumeGenerator(); // Natija: 1, 2, 3, 4, 5 (kechikishlar bilan)
            

              
                Copy
              
            
          

Asinxron Oqimlarda Xatoliklarni Boshqarish Muammosi

Asinxron oqimlarda xatoliklarni boshqarish sinxron kod bilan solishtirganda o'ziga xos qiyinchiliklarni keltirib chiqaradi. An'anaviy try/catch bloklari faqat bevosita sinxron doirada yuzaga keladigan xatoliklarni ushlay oladi. Asinxron iterator yoki generator ichidagi asinxron operatsiyalar bilan ishlaganda, xatoliklar turli vaqt nuqtalarida yuzaga kelishi mumkin, bu esa xatoliklarni uzatish uchun yanada murakkab yondashuvni talab qiladi.

Masofaviy API-dan ma'lumotlarni qayta ishlayotgan vaziyatni tasavvur qiling. API istalgan vaqtda, masalan, tarmoq uzilishi yoki server tomonidagi muammo kabi xatolikni qaytarishi mumkin. Sizning ilovangiz ushbu xatoliklarni to'g'ri boshqarish, ularni qayd etish va potentsial ravishda operatsiyani qayta urinish yoki zaxira qiymatini taqdim etishga qodir bo'lishi kerak.

Async Iterator Yordamchilarida Xatoliklarni Uzatish Strategiyalari

Asinxron iterator yordamchilarida xatoliklarni samarali boshqarish uchun bir nechta strategiyalarni qo'llash mumkin. Keling, eng keng tarqalgan va samarali usullardan ba'zilarini ko'rib chiqaylik.

1. Asinxron Generator Funksiyasi Ichidagi Try/Catch Bloklari

Eng to'g'ridan-to'g'ri yondashuvlardan biri bu asinxron generator funksiyasi ichidagi asinxron operatsiyalarni try/catch bloklariga o'rashdir. Bu sizga generatorning bajarilishi paytida yuzaga keladigan xatoliklarni ushlash va ularni mos ravishda boshqarish imkonini beradi.

Misol:

            async function* fetchData(urls) {
  for (const url of urls) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP xatosi! status: ${response.status}`);
      }
      const data = await response.json();
      yield data;
    } catch (error) {
      console.error(`${url} manzilidan ma'lumot olishda xatolik:`, error);
      // Ixtiyoriy ravishda, zaxira qiymatini qaytarish yoki xatolikni qayta yuborish
      yield { error: error.message, url: url }; // Xatolik obyektini qaytarish
    }
  }
}

async function consumeData() {
  for await (const item of fetchData(['https://example.com/data1', 'https://example.com/data2'])) {
    if (item.error) {
      console.warn(`URL uchun xatolik yuz berdi: ${item.url}, Xatolik: ${item.error}`);
    } else {
      console.log('Qabul qilingan ma\'lumotlar:', item);
    }
  }
}

consumeData();
            

              
                Copy
              
            
          

Ushbu misolda fetchData generator funksiyasi URL-lar ro'yxatidan ma'lumotlarni oladi. Agar yuklash operatsiyasi paytida xatolik yuz bersa, catch bloki xatolikni qayd etadi va xatolik obyektini qaytaradi. Keyin iste'molchi funksiyasi qaytarilgan qiymatdagi error xususiyatini tekshiradi va uni mos ravishda boshqaradi. Bu usul xatoliklarning lokalizatsiya qilinishini va generator ichida boshqarilishini ta'minlaydi, bu esa butun oqimning ishdan chiqishini oldini oladi.

2. Xatoliklarni Boshqarish Uchun `Promise.prototype.catch` dan Foydalanish

Yana bir keng tarqalgan usul - bu asinxron generator funksiyasi ichidagi promislarda .catch() metodidan foydalanish. Bu sizga promisning hal qilinishi paytida yuzaga keladigan xatoliklarni boshqarish imkonini beradi.

Misol:

            async function* fetchData(urls) {
  for (const url of urls) {
    const promise = fetch(url)
      .then(response => {
        if (!response.ok) {
          throw new Error(`HTTP xatosi! status: ${response.status}`);
        }
        return response.json();
      })
      .catch(error => {
        console.error(`${url} manzilidan ma'lumot olishda xatolik:`, error);
        return { error: error.message, url: url }; // Xatolik obyektini qaytarish
      });

    yield await promise;
  }
}

async function consumeData() {
  for await (const item of fetchData(['https://example.com/data1', 'https://example.com/data2'])) {
    if (item.error) {
      console.warn(`URL uchun xatolik yuz berdi: ${item.url}, Xatolik: ${item.error}`);
    } else {
      console.log('Qabul qilingan ma\'lumotlar:', item);
    }
  }
}

consumeData();
            

              
                Copy
              
            
          

Ushbu misolda .catch() metodi yuklash operatsiyasi paytida yuzaga keladigan xatoliklarni boshqarish uchun ishlatiladi. Agar xatolik yuz bersa, catch bloki xatolikni qayd etadi va xatolik obyektini qaytaradi. Keyin generator funksiyasi promis natijasini qaytaradi, bu esa olingan ma'lumot yoki xatolik obyekti bo'ladi. Bu yondashuv promisning hal qilinishi paytida yuzaga keladigan xatoliklarni boshqarishning toza va ixcham usulini ta'minlaydi.

3. Maxsus Xatoliklarni Boshqarish Yordamchi Funksiyasini Yaratish

Murakkabroq xatoliklarni boshqarish stsenariylari uchun maxsus xatoliklarni boshqarish yordamchi funksiyasini yaratish foydali bo'lishi mumkin. Bu funksiya xatoliklarni boshqarish mantig'ini o'z ichiga oladi va butun ilovangizda xatoliklarni boshqarishning izchil usulini ta'minlaydi.

Misol:

            async function safeFetch(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP xatosi! status: ${response.status}`);
    }
    return await response.json();
  } catch (error) {
    console.error(`${url} manzilidan ma'lumot olishda xatolik:`, error);
    return { error: error.message, url: url }; // Xatolik obyektini qaytarish
  }
}

async function* fetchData(urls) {
  for (const url of urls) {
    yield await safeFetch(url);
  }
}

async function consumeData() {
  for await (const item of fetchData(['https://example.com/data1', 'https://example.com/data2'])) {
    if (item.error) {
      console.warn(`URL uchun xatolik yuz berdi: ${item.url}, Xatolik: ${item.error}`);
    } else {
      console.log('Qabul qilingan ma\'lumotlar:', item);
    }
  }
}

consumeData();
            

              
                Copy
              
            
          

Ushbu misolda safeFetch funksiyasi yuklash operatsiyasi uchun xatoliklarni boshqarish mantig'ini o'z ichiga oladi. Keyin fetchData generator funksiyasi har bir URL dan ma'lumotlarni olish uchun safeFetch funksiyasidan foydalanadi. Bu yondashuv kodning qayta ishlatiluvchanligi va qo'llab-quvvatlanuvchanligini oshiradi.

4. Asinxron Iterator Yordamchilaridan Foydalanish: `map`, `filter`, `reduce` va Xatoliklarni Boshqarish

JavaScript-ning asinxron iterator yordamchilari (`map`, `filter`, `reduce` va boshqalar) asinxron oqimlarni o'zgartirish va qayta ishlashning qulay usullarini taqdim etadi. Ushbu yordamchilardan foydalanganda, xatoliklarning qanday uzatilishini va ularni qanday qilib samarali boshqarishni tushunish juda muhimdir.

a) `map` da Xatoliklarni Boshqarish

map yordamchisi asinxron oqimning har bir elementiga o'zgartirish funksiyasini qo'llaydi. Agar o'zgartirish funksiyasi xatolik yuborsa, xatolik iste'molchiga uzatiladi.

Misol:

            async function* generateNumbers(n) {
  for (let i = 1; i <= n; i++) {
    yield i;
  }
}

async function consumeData() {
  try {
    const asyncIterable = generateNumbers(5);

    const mappedIterable = asyncIterable.map(async (num) => {
      if (num === 3) {
        throw new Error('3-sonni qayta ishlashda xatolik');
      }
      return num * 2;
    });

    for await (const item of mappedIterable) {
      console.log(item);
    }
  } catch (error) {
    console.error('Xatolik yuz berdi:', error);
  }
}

consumeData(); // Natija: 2, 4, Xatolik yuz berdi: Error: 3-sonni qayta ishlashda xatolik
            

              
                Copy
              
            
          

Ushbu misolda o'zgartirish funksiyasi 3-sonni qayta ishlashda xatolik yuboradi. Xatolik consumeData funksiyasidagi catch bloki tomonidan ushlanadi. E'tibor bering, xatolik iteratsiyani to'xtatadi.

b) `filter` da Xatoliklarni Boshqarish

filter yordamchisi predikat funksiyasi asosida asinxron oqimning elementlarini filtrlaydi. Agar predikat funksiyasi xatolik yuborsa, xatolik iste'molchiga uzatiladi.

Misol:

            async function* generateNumbers(n) {
  for (let i = 1; i <= n; i++) {
    yield i;
  }
}

async function consumeData() {
  try {
    const asyncIterable = generateNumbers(5);

    const filteredIterable = asyncIterable.filter(async (num) => {
      if (num === 3) {
        throw new Error('3-sonni filtrlashda xatolik');
      }
      return num % 2 === 0;
    });

    for await (const item of filteredIterable) {
      console.log(item);
    }
  } catch (error) {
    console.error('Xatolik yuz berdi:', error);
  }
}

consumeData(); // Natija: Xatolik yuz berdi: Error: 3-sonni filtrlashda xatolik
            

              
                Copy
              
            
          

Ushbu misolda predikat funksiyasi 3-sonni qayta ishlashda xatolik yuboradi. Xatolik consumeData funksiyasidagi catch bloki tomonidan ushlanadi.

c) `reduce` da Xatoliklarni Boshqarish

reduce yordamchisi reduktor funksiyasi yordamida asinxron oqimni bitta qiymatga qisqartiradi. Agar reduktor funksiyasi xatolik yuborsa, xatolik iste'molchiga uzatiladi.

Misol:

            async function* generateNumbers(n) {
  for (let i = 1; i <= n; i++) {
    yield i;
  }
}

async function consumeData() {
  try {
    const asyncIterable = generateNumbers(5);

    const sum = await asyncIterable.reduce(async (acc, num) => {
      if (num === 3) {
        throw new Error('3-sonni qisqartirishda xatolik');
      }
      return acc + num;
    }, 0);

    console.log('Yig\'indi:', sum);
  } catch (error) {
    console.error('Xatolik yuz berdi:', error);
  }
}

consumeData(); // Natija: Xatolik yuz berdi: Error: 3-sonni qisqartirishda xatolik
            

              
                Copy
              
            
          

Ushbu misolda reduktor funksiyasi 3-sonni qayta ishlashda xatolik yuboradi. Xatolik consumeData funksiyasidagi catch bloki tomonidan ushlanadi.

5. `process.on('unhandledRejection')` (Node.js) yoki `window.addEventListener('unhandledrejection')` (Brauzerlar) bilan Global Xatoliklarni Boshqarish

Garchi asinxron iteratorlarga xos bo'lmasa-da, global xatoliklarni boshqarish mexanizmlarini sozlash sizning oqimlaringizda yuzaga kelishi mumkin bo'lgan ishlov berilmagan promis rad etishlari uchun xavfsizlik tarmog'ini ta'minlashi mumkin. Bu ayniqsa Node.js muhitida muhimdir.

Node.js Misoli:

            process.on('unhandledRejection', (reason, promise) => {
  console.error('Ishlov berilmagan rad etish:', promise, 'sabab:', reason);
  // Ixtiyoriy ravishda, tozalashni amalga oshiring yoki jarayonni tugating
});

async function* generateNumbers(n) {
  for (let i = 1; i <= n; i++) {
    if (i === 3) {
      throw new Error('Simulyatsiya qilingan xato'); // Agar lokal ushlanmasa, bu ishlov berilmagan rad etishga olib keladi
    }
    yield i;
  }
}

async function main() {
  const iterator = generateNumbers(5);
  for await (const num of iterator) {
    console.log(num);
  }
}

main(); // Agar generator ichidagi xatolik bartaraf etilmasa, 'unhandledRejection' ishga tushadi.
            

              
                Copy
              
            
          

Brauzer Misoli:

            window.addEventListener('unhandledrejection', (event) => {
  console.error('Ishlov berilmagan rad etish:', event.reason, event.promise);
  // Bu yerda xatolikni qayd etishingiz yoki foydalanuvchiga qulay xabar ko'rsatishingiz mumkin.
});

async function fetchData(url) {
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`HTTP xatosi! status: ${response.status}`); // Agar `fetchData` try/catch bilan o'ralmagan bo'lsa, ishlov berilmagan rad etishga olib kelishi mumkin
  }
  return response.json();
}

async function processData() {
  const data = await fetchData('https://example.com/api/nonexistent'); // Xatolikka olib kelishi mumkin bo'lgan URL.
  console.log(data);
}

processData();
            

              
                Copy
              
            
          

Muhim Jihatlar:

• Nosozliklarni tuzatish: Global ishlovchilar ishlov berilmagan rad etishlarni qayd etish va nosozliklarni tuzatish uchun qimmatlidir.
• Tozalash: Ilova ishdan chiqishidan oldin tozalash operatsiyalarini bajarish uchun ushbu ishlovchilardan foydalanishingiz mumkin.
• Ishdan chiqishni oldini olish: Garchi ular xatoliklarni qayd etsa-da, ular xatolik mantiqni tubdan buzgan taqdirda ilovaning potentsial ishdan chiqishini oldini ololmaydi. Shuning uchun, asinxron oqimlar ichidagi lokal xatoliklarni boshqarish har doim asosiy himoya hisoblanadi.

Async Iterator Yordamchilarida Xatoliklarni Boshqarishning Eng Yaxshi Amaliyotlari

Asinxron iterator yordamchilaringizda mustahkam xatoliklarni boshqarishni ta'minlash uchun quyidagi eng yaxshi amaliyotlarni ko'rib chiqing:

• Xatoliklarni lokalizatsiya qilish: Xatoliklarni ularning manbasiga iloji boricha yaqinroq boshqaring. Asinxron operatsiyalar paytida yuzaga keladigan xatoliklarni ushlash uchun asinxron generator funksiyasi ichida try/catch bloklari yoki .catch() metodlaridan foydalaning.
• Zaxira qiymatlarni taqdim etish: Xatolik yuz berganda, butun oqimning ishdan chiqishini oldini olish uchun zaxira qiymat yoki standart qiymat qaytarishni ko'rib chiqing. Bu iste'molchiga ba'zi elementlar noto'g'ri bo'lsa ham oqimni qayta ishlashni davom ettirishga imkon beradi.
• Xatoliklarni qayd etish: Nosozliklarni tuzatishni osonlashtirish uchun xatoliklarni etarli darajada batafsil qayd eting. URL, xatolik xabari va stek izi kabi ma'lumotlarni qo'shing.
• Operatsiyalarni qayta urinish: Vaqtinchalik xatoliklar, masalan, tarmoq uzilishlari uchun, qisqa kechikishdan keyin operatsiyani qayta urinishni ko'rib chiqing. Cheksiz tsikllardan qochish uchun maksimal urinishlar soni bilan qayta urinish mexanizmini joriy qiling.
• Maxsus xatoliklarni boshqarish yordamchi funksiyasidan foydalanish: Kodning qayta ishlatiluvchanligi va qo'llab-quvvatlanuvchanligini oshirish uchun xatoliklarni boshqarish mantig'ini maxsus yordamchi funksiyaga o'rang.
• Global xatoliklarni boshqarishni ko'rib chiqish: Ishlov berilmagan promis rad etishlarini ushlash uchun Node.js-dagi process.on('unhandledRejection') kabi global xatoliklarni boshqarish mexanizmlarini joriy qiling. Biroq, asosiy himoya sifatida lokal xatoliklarni boshqarishga tayaning.
• To'g'ri to'xtatish: Server tomonidagi ilovalarda, asinxron oqimni qayta ishlash kodingiz ma'lumotlar yo'qolishini oldini olish va toza to'xtatishni ta'minlash uchun SIGINT (Ctrl+C) va SIGTERM kabi signallarni to'g'ri boshqarishini ta'minlang. Bu resurslarni (ma'lumotlar bazasi ulanishlari, fayl dastaklari, tarmoq ulanishlari) yopish va kutayotgan operatsiyalarni yakunlashni o'z ichiga oladi.
• Monitoring va ogohlantirish: Asinxron oqimni qayta ishlash kodingizdagi xatoliklarni aniqlash va ularga javob berish uchun monitoring va ogohlantirish tizimlarini joriy qiling. Bu sizga muammolarni foydalanuvchilaringizga ta'sir qilishidan oldin aniqlash va tuzatishga yordam beradi.

Amaliy Misollar: Haqiqiy Hayotiy Vaziyatlarda Xatoliklarni Boshqarish

Keling, asinxron iterator yordamchilari bilan bog'liq haqiqiy hayotiy vaziyatlarda xatoliklarni boshqarishning ba'zi amaliy misollarini ko'rib chiqaylik.

1-Misol: Zaxira Mexanizmi Bilan Bir Nechta APIlardan Ma'lumotlarni Qayta Ishlash

Siz bir nechta API-dan ma'lumotlarni olishingiz kerakligini tasavvur qiling. Agar bitta API ishlamay qolsa, siz zaxira API-dan foydalanishni yoki standart qiymatni qaytarishni xohlaysiz.

            async function safeFetch(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP xatosi! status: ${response.status}`);
    }
    return await response.json();
  } catch (error) {
    console.error(`${url} manzilidan ma'lumot olishda xatolik:`, error);
    return null; // Muvaffaqiyatsizlikni bildirish
  }
}

async function* fetchDataWithFallback(apiUrls, fallbackUrl) {
  for (const apiUrl of apiUrls) {
    let data = await safeFetch(apiUrl);
    if (data === null) {
      console.log(`${apiUrl} uchun zaxiraga urinish`);
      data = await safeFetch(fallbackUrl);
      if (data === null) {
        console.warn(`${apiUrl} uchun zaxira ham ishlamadi. Standart qiymat qaytarilmoqda.`);
        yield { error: `${apiUrl} va zaxiradan ma'lumotlarni olishda xatolik.` };
        continue; // Keyingi URL manziliga o'tish
      }
    }
    yield data;
  }
}

async function processData() {
  const apiUrls = ['https://api.example.com/data1', 'https://api.nonexistent.com/data2', 'https://api.example.com/data3'];
  const fallbackUrl = 'https://backup.example.com/default_data';
  for await (const item of fetchDataWithFallback(apiUrls, fallbackUrl)) {
    if (item.error) {
      console.warn(`Ma'lumotlarni qayta ishlashda xatolik: ${item.error}`);
    } else {
      console.log('Qayta ishlangan ma\'lumotlar:', item);
    }
  }
}

processData();
            

              
                Copy
              
            
          

Ushbu misolda fetchDataWithFallback generator funksiyasi API-lar ro'yxatidan ma'lumotlarni olishga harakat qiladi. Agar API ishlamay qolsa, u zaxira API-dan ma'lumotlarni olishga harakat qiladi. Agar zaxira API ham ishlamay qolsa, u ogohlantirishni qayd etadi va xatolik obyektini qaytaradi. Keyin iste'molchi funksiyasi xatolikni mos ravishda boshqaradi.

2-Misol: Xatoliklarni Boshqarish Bilan So'rovlarni Cheklash (Rate Limiting)

API-lar bilan, ayniqsa uchinchi tomon API-lari bilan ishlashda, API-ning foydalanish chegaralaridan oshib ketmaslik uchun ko'pincha so'rovlarni cheklashni joriy qilish kerak bo'ladi. So'rovlar chegarasi xatolarini boshqarish uchun to'g'ri xatoliklarni boshqarish muhimdir.

            const rateLimit = 5; // Bir soniyadagi so'rovlar soni
let requestCount = 0;
let lastRequestTime = 0;

async function throttledFetch(url) {
  const now = Date.now();
  if (requestCount >= rateLimit && now - lastRequestTime < 1000) {
    const delay = 1000 - (now - lastRequestTime);
    console.log(`So'rovlar chegarasi oshib ketdi. ${delay}ms kutilmoqda...`);
    await new Promise(resolve => setTimeout(resolve, delay));
  }

  try {
    const response = await fetch(url);
    if (response.status === 429) { // So'rovlar chegarasi oshib ketdi
      console.warn('So\'rovlar chegarasi oshib ketdi. Kechikishdan keyin qayta urinilmoqda...');
      await new Promise(resolve => setTimeout(resolve, 2000)); // Uzoqroq kutish
      return throttledFetch(url); // Qayta urinish
    }

    if (!response.ok) {
      throw new Error(`HTTP xatosi! status: ${response.status}`);
    }

    const data = await response.json();
    requestCount++;
    lastRequestTime = Date.now();
    return data;

  } catch (error) {
    console.error(`${url} manzilini olishda xatolik:`, error);
    throw error; // Qayd etgandan keyin xatolikni qayta yuborish
  }
}

async function* fetchUrls(urls) {
  for (const url of urls) {
    try {
      yield await throttledFetch(url);
    } catch (err) {
      console.error(`Qayta urinishlardan keyin ${url} URL manzilini olishda xatolik. O'tkazib yuborilmoqda.`);
      yield { error: `${url} manzilini olishda xatolik` }; // Iste'molchiga xatolik signali
    }
  }
}

async function consumeData() {
  const urls = ['https://api.example.com/resource1', 'https://api.example.com/resource2', 'https://api.example.com/resource3'];
  for await (const item of fetchUrls(urls)) {
    if (item.error) {
      console.warn(`Xatolik: ${item.error}`);
    } else {
      console.log('Ma\'lumotlar:', item);
    }
  }
}

consumeData();
            

              
                Copy
              
            
          

Ushbu misolda throttledFetch funksiyasi bir soniya ichida qilingan so'rovlar sonini kuzatib borish orqali so'rovlarni cheklashni amalga oshiradi. Agar so'rovlar chegarasi oshib ketsa, keyingi so'rovni yuborishdan oldin qisqa kechikish kutadi. Agar 429 (Juda Ko'p So'rovlar) xatosi olinsa, u uzoqroq kutadi va so'rovni qayta urinadi. Xatolar ham qayd etiladi va chaqiruvchi tomonidan boshqarilishi uchun qayta yuboriladi.

Xulosa

Xatoliklarni boshqarish asinxron dasturlashning, ayniqsa asinxron iteratorlar va asinxron generator funksiyalari bilan ishlashda muhim jihatidir. Xatoliklarni uzatish strategiyalarini tushunish va eng yaxshi amaliyotlarni joriy qilish orqali siz xatoliklarni to'g'ri boshqaradigan va kutilmagan ishdan chiqishlarni oldini oladigan mustahkam va ishonchli oqimli ilovalar yaratishingiz mumkin. Lokal xatoliklarni boshqarishga ustuvorlik berishni, zaxira qiymatlarni taqdim etishni, xatoliklarni samarali qayd etishni va qo'shimcha barqarorlik uchun global xatoliklarni boshqarish mexanizmlarini ko'rib chiqishni unutmang. Har doim muvaffaqiyatsizlikka mo'ljallab loyihalashtiring va ilovalaringizni xatoliklardan keyin to'g'ri tiklanadigan qilib yarating.